const hexcase = 0 /* hex output format. 0 - lowercase; 1 - uppercase */
const chrsz = 8/* bits per input character. 8 - ASCII; 16 - Unicode */

function rol (num, cnt) {
  return (num << cnt) | (num >>> (32 - cnt))
}
function safeAdd (x, y) {
  let lsw = (x & 0xFFFF) + (y & 0xFFFF)
  let msw = (x >> 16) + (y >> 16) + (lsw >> 16)
  return (msw << 16) | (lsw & 0xFFFF)
}

/*
 *
 * Calculate the SHA-1 of an array of big-endian words, and a bit length
 *
 */

/*
 *
 * Perform the appropriate triplet combination function for the current
 * iteration
 *
 * 返回对应F函数的值
 *
 */
function sha1FT (t, b, c, d) {
  if (t < 20) {
    return (b & c) | ((~b) & d)
  }
  if (t < 40) {
    return b ^ c ^ d
  }
  if (t < 60) {
    return (b & c) | (b & d) | (c & d)
  }
  return b ^ c ^ d // t<80
}

/*
 *
 * Determine the appropriate additive constant for the current iteration
 *
 * 返回对应的Kt值
 *
 */
function sha1KT (t) {
  return (t < 20) ? 1518500249 : (t < 40) ? 1859775393 : (t < 60) ? -1894007588 : -899497514;
}

function coreSha (blockArray) {
  let x = blockArray
  let w = Array(80)
  let a = 1732584193
  let b = -271733879
  let c = -1732584194
  let d = 271733878
  let e = -1009589776
  // 每次处理512位 16*32
  for (let i = 0; i < x.length; i += 16) {
    let olda = a
    let oldb = b
    let oldc = c
    let oldd = d
    let olde = e
    for (let j = 0; j < 80; j++) {
      if (j < 16) {
        w[j] = x[i + j]
      } else {
        w[j] = rol(w[j - 3] ^ w[j - 8] ^ w[j - 14] ^ w[j - 16], 1)
      }
      let t = safeAdd(safeAdd(rol(a, 5), sha1FT(j, b, c, d)), safeAdd(safeAdd(e, w[j]), sha1KT(j)))
      e = d
      d = c
      c = rol(b, 30)
      b = a
      a = t
    }
    a = safeAdd(a, olda)
    b = safeAdd(b, oldb)
    c = safeAdd(c, oldc)
    d = safeAdd(d, oldd)
    e = safeAdd(e, olde)
  }
  return [a, b, c, d, e]
}

function binb2hex (binarray) {
  let hexTab = hexcase ? '0123456789ABCDEF' : '0123456789abcdef'
  let str = ''
  for (let i = 0; i < binarray.length * 4; i++) {
    str += hexTab.charAt((binarray[i >> 2] >> ((3 - i % 4) * 8 + 4)) & 0xF) +
      hexTab.charAt((binarray[i >> 2] >> ((3 - i % 4) * 8)) & 0xF)
  }
  return str
}
/*
 *
 * Add integers, wrapping at 2^32. This uses 16-bit operations internally
 *
 * to work around bugs in some JS interpreters.
 *
 * 将32位数拆成高16位和低16位分别进行相加，从而实现 MOD 2^32 的加法
 *
 */

/*
 *
 * Bitwise rotate a 32-bit number to the left.
 *
 * 32位二进制数循环左移
 *
 */

/*
 *
 * The standard SHA1 needs the input string to fit into a block
 *
 * This function align the input string to meet the requirement
 *
 */
function AlignSHA1 (str) {
  let nblk = ((str.length + 8) >> 6) + 1, blks = new Array(nblk * 16)
  for (let i = 0; i < nblk * 16; i++)
    blks[i] = 0;
  for (i = 0; i < str.length; i++)
    blks[i >> 2] |= str.charCodeAt(i) << (24 - (i & 3) * 8);
  blks[i >> 2] |= 0x80 << (24 - (i & 3) * 8);
  blks[nblk * 16 - 1] = str.length * 8;
  return blks;
}
function hexSha1 (s) {
  return binb2hex(coreSha(AlignSHA1(s)))
}

/*
 *
 * Convert an array of big-endian words to a hex string.
 *
 */


export default hexSha1
